#include "KcpChannel.h"
#include "thirdpart/kcp/ikcp.h"
#include <algorithm>
#include <chrono>

namespace SeanNetwork {

// KCP会话实现
KcpChannel::KcpSession::KcpSession() : m_KcpCb(nullptr) {
}

KcpChannel::KcpSession::~KcpSession() {
    // 确保在析构函数中始终调用Release清理资源
    Release();
}

bool KcpChannel::KcpSession::Create(uint32_t conv) {
    /* 功能：创建KCP会话
       参数：conv-会话ID
       返回：创建是否成功 */
    if (m_KcpCb) {
        // 如果已存在实例，先释放旧实例再创建新的
        Release();
    }
    
    // 创建KCP控制块
    m_KcpCb = ikcp_create(conv, this);
    if (!m_KcpCb) {
        return false;
    }
    
    // 设置KCP回调
    ikcp_setoutput(static_cast<ikcpcb*>(m_KcpCb), [](const char* buf, int len, ikcpcb* kcp, void* user) -> int {
        KcpSession* session = static_cast<KcpSession*>(user);
        if (session && session->m_OutputCallback) {
            return session->m_OutputCallback(reinterpret_cast<const uint8_t*>(buf), len);
        }
        return 0;
    });
    
    // 默认配置
    ikcp_nodelay(static_cast<ikcpcb*>(m_KcpCb), 1, 10, 2, 1);  // 快速模式
    ikcp_wndsize(static_cast<ikcpcb*>(m_KcpCb), 128, 128);     // 窗口大小
    ikcp_setmtu(static_cast<ikcpcb*>(m_KcpCb), 1400);          // MTU大小
    
    return true;
}

void KcpChannel::KcpSession::Release() {
    /* 功能：释放KCP会话 */
    if (m_KcpCb) {
        ikcp_release(static_cast<ikcpcb*>(m_KcpCb));
        m_KcpCb = nullptr;
    }
}

bool KcpChannel::KcpSession::IsCreated() const {
    return m_KcpCb != nullptr;
}

bool KcpChannel::KcpSession::Send(const uint8_t* data, int size) {
    /* 功能：通过KCP发送数据
       参数：data-数据指针，size-数据长度
       返回：发送是否成功 */
    if (!m_KcpCb || !data || size <= 0) {
        return false;
    }
    
    return ikcp_send(static_cast<ikcpcb*>(m_KcpCb), reinterpret_cast<const char*>(data), size) == 0;
}

int KcpChannel::KcpSession::Recv(uint8_t* data, int size) {
    /* 功能：从KCP接收数据
       参数：data-接收缓冲区，size-缓冲区大小
       返回：接收到的数据长度，<0表示错误 */
    if (!m_KcpCb || !data || size <= 0) {
        return -1;
    }
    
    return ikcp_recv(static_cast<ikcpcb*>(m_KcpCb), reinterpret_cast<char*>(data), size);
}

void KcpChannel::KcpSession::Update(uint32_t current) {
    /* 功能：更新KCP状态
       参数：current-当前时间戳（毫秒） */
    if (m_KcpCb) {
        ikcp_update(static_cast<ikcpcb*>(m_KcpCb), current);
    }
}

uint32_t KcpChannel::KcpSession::Check(uint32_t current) {
    /* 功能：检查KCP下次更新时间
       参数：current-当前时间戳（毫秒）
       返回：下次需要更新的时间戳 */
    if (!m_KcpCb) {
        return current + 1000;  // 默认1秒后
    }
    
    return ikcp_check(static_cast<ikcpcb*>(m_KcpCb), current);
}

void KcpChannel::KcpSession::SetOutput(std::function<int(const uint8_t*, int)> output) {
    m_OutputCallback = output;
}

void KcpChannel::KcpSession::SetNodelay(bool nodelay, int interval, int resend, bool nc) {
    /* 功能：设置KCP传输模式
       参数：nodelay-是否启用无延迟模式，interval-内部更新间隔(ms)
             resend-快速重传触发次数，nc-是否关闭流控 */
    if (m_KcpCb) {
        ikcp_nodelay(static_cast<ikcpcb*>(m_KcpCb), nodelay ? 1 : 0, interval, resend, nc ? 1 : 0);
    }
}

void KcpChannel::KcpSession::SetWindowSize(int sndwnd, int rcvwnd) {
    /* 功能：设置KCP窗口大小
       参数：sndwnd-发送窗口大小，rcvwnd-接收窗口大小 */
    if (m_KcpCb) {
        ikcp_wndsize(static_cast<ikcpcb*>(m_KcpCb), sndwnd, rcvwnd);
    }
}

void KcpChannel::KcpSession::SetMtu(int mtu) {
    /* 功能：设置最大传输单元
       参数：mtu-MTU大小 */
    if (m_KcpCb) {
        ikcp_setmtu(static_cast<ikcpcb*>(m_KcpCb), mtu);
    }
}

void KcpChannel::KcpSession::SetMinRto(int minrto) {
    /* 功能：设置最小RTO
       参数：minrto-最小重传超时时间(ms) */
    if (m_KcpCb) {
        ikcpcb* kcp = static_cast<ikcpcb*>(m_KcpCb);
        kcp->rx_minrto = minrto;
    }
}

void KcpChannel::KcpSession::SetFastResend(int fastresend) {
    /* 功能：设置快速重传
       参数：fastresend-触发快速重传的ACK跳过次数 */
    if (m_KcpCb) {
        ikcp_nodelay(static_cast<ikcpcb*>(m_KcpCb), 1, 10, fastresend, 1);
    }
}

uint32_t KcpChannel::KcpSession::GetLatestRtt() const {
    /* 功能：获取最新的RTT值
       返回：往返时间(ms) */
    if (!m_KcpCb) {
        return 0;
    }
    
    ikcpcb* kcp = static_cast<ikcpcb*>(m_KcpCb);
    return kcp->rx_rttval;
}

void* KcpChannel::KcpSession::GetKcpCb() const {
    return m_KcpCb;
}

// KcpChannel实现
KcpChannel::KcpChannel(asio::io_context& ioContext)
    : BaseNetworkChannel(ioContext),
      m_Socket(ioContext),
      m_KcpConv(0),
      m_UpdateInterval(10),          // 10ms更新间隔
      m_KeepAliveInterval(3000),     // 3秒心跳间隔
      m_IsReceiving(false) {
    
    m_KcpSession = std::make_unique<KcpSession>();
    
    m_ReadBuffer.resize(4096);      // KCP接收缓冲区
    m_RawReadBuffer.resize(2048);   // UDP原始接收缓冲区
    
    // 设置消息确认回调
    m_MessagePool->SetAckCallback([this](uint32_t messageId, bool success) {
        HandleMessageAck(messageId, success);
    });
}

KcpChannel::~KcpChannel() {
    try {
        // 确保在析构函数中显式调用断开连接和清理资源
        Disconnect();
        
        // 确保KCP会话被正确释放
        if (m_KcpSession) {
            m_KcpSession->Release();
            m_KcpSession.reset();
        }
        
        // 取消所有定时器
        if (m_UpdateTimer) {
            asio::error_code ec;
            m_UpdateTimer->cancel(ec);
            m_UpdateTimer.reset();
        }
        
        if (m_KeepAliveTimer) {
            asio::error_code ec;
            m_KeepAliveTimer->cancel(ec);
            m_KeepAliveTimer.reset();
        }
        
        if (m_ReconnectTimer) {
            asio::error_code ec;
            m_ReconnectTimer->cancel(ec);
            m_ReconnectTimer.reset();
        }
        
        // 关闭套接字
        if (m_Socket.is_open()) {
            asio::error_code ec;
            m_Socket.close(ec);
        }
    }
    catch (const std::exception& e) {
        // 记录错误但不抛出异常，因为这是析构函数
        // 实际环境中应使用日志系统记录这个错误
        // std::cerr << "Exception in KcpChannel destructor: " << e.what() << std::endl;
    }
}

bool KcpChannel::Initialize() {
    return BaseNetworkChannel::Initialize();
}

bool KcpChannel::Connect(const std::string& host, uint16_t port) {
    return BaseNetworkChannel::Connect(host, port);
}

void KcpChannel::Disconnect() {
    BaseNetworkChannel::Disconnect();
}

void KcpChannel::Update() {
    BaseNetworkChannel::Update();
}

bool KcpChannel::DoInitialize() {
    try {
        // 初始化KCP会话
        if (m_KcpSession) {
            m_KcpSession->Release();
            m_KcpConv = static_cast<uint32_t>(std::chrono::system_clock::now().time_since_epoch().count() & 0xFFFFFFFF);
            if (!m_KcpSession->Create(m_KcpConv)) {
                return false;
            }
        }
        
        // 创建并配置UDP套接字
        asio::error_code ec;
        if (m_Socket.is_open()) {
            m_Socket.close(ec);
        }
        m_Socket.open(asio::ip::udp::v4(), ec);
        if (ec) {
            return false;
        }
        
        // 创建并配置定时器
        if (m_UpdateTimer) {
            m_UpdateTimer->cancel(ec);
        }
        m_UpdateTimer = std::make_shared<asio::steady_timer>(m_IoContext);
        
        if (m_KeepAliveTimer) {
            m_KeepAliveTimer->cancel(ec);
        }
        m_KeepAliveTimer = std::make_shared<asio::steady_timer>(m_IoContext);
        
        if (m_ReconnectTimer) {
            m_ReconnectTimer->cancel(ec);
        }
        m_ReconnectTimer = std::make_shared<asio::steady_timer>(m_IoContext);
        
        // 设置KCP会话参数
        m_KcpSession->SetNodelay(true, 10, 2, true);  // 默认激进模式
        m_KcpSession->SetWindowSize(128, 128);        // 默认窗口大小
        
        return true;
    }
    catch (const std::exception&) {
        return false;
    }
}

bool KcpChannel::DoConnect(const std::string& host, uint16_t port) {
    /* 功能：连接到远程主机
       参数：host-主机地址，port-端口号
       返回：连接操作是否成功启动 */
    if (m_State == ConnectionState::Connected || m_State == ConnectionState::Connecting) {
        return false;
    }
    
    // 在启动连接操作前设置状态
    UpdateConnectionState(ConnectionState::Connecting);
    
    try {
        // 解析地址
        asio::ip::udp::resolver resolver(m_IoContext);
        auto endpoints = resolver.resolve(host, std::to_string(port));
        
        m_RemoteEndpoint = *endpoints.begin();
        
        // 设置KCP回调函数
        m_KcpSession->SetOutput([this](const uint8_t* data, int size) -> int {
            return UdpOutput(data, size);
        });
        
        // 启动接收和定时器
        StartReceive();
        StartKcpUpdate();
        
        // 发送连接请求包 - 使用shared_ptr确保buffer在异步操作期间存活
        auto connectPacket = std::make_shared<std::vector<uint8_t>>(8);
        (*connectPacket)[0] = 'C';
        (*connectPacket)[1] = 'O';
        (*connectPacket)[2] = 'N';
        (*connectPacket)[3] = 'N';
        std::memcpy(&(*connectPacket)[4], &m_KcpConv, 4);
        
        m_Socket.async_send_to(asio::buffer(*connectPacket), m_RemoteEndpoint,
            asio::bind_executor(m_Strand, [this, connectPacket](const asio::error_code& ec, std::size_t bytes_transferred) {
                if (!ec) {
                    // 连接请求发送成功，更新状态为Connected
                    UpdateConnectionState(ConnectionState::Connected);
                    SendKeepAlive();
                }
                else {
                    // 连接请求发送失败，更新状态为Failed
                    std::string errMsg = "Connect error: " + ec.message();
                    UpdateConnectionState(ConnectionState::Failed, errMsg);
                    StartReconnect();
                }
            }));
        
        return true;
    }
    catch (const std::exception& e) {
        UpdateConnectionState(ConnectionState::Failed, std::string("Connect exception: ") + e.what());
        StartReconnect();
        return false;
    }
}

void KcpChannel::DoDisconnect() {
    /* 功能：断开连接 */
    if (m_State == ConnectionState::Disconnected) {
        return;
    }
    
    // 停止所有定时器
    asio::error_code ec;
    if (m_UpdateTimer) {
        m_UpdateTimer->cancel(ec);
    }
    
    if (m_KeepAliveTimer) {
        m_KeepAliveTimer->cancel(ec);
    }
    
    if (m_ReconnectTimer) {
        m_ReconnectTimer->cancel(ec);
    }
    
    // 释放KCP会话
    if (m_KcpSession) {
        m_KcpSession->Release();
    }
    
    // 关闭套接字
    if (m_Socket.is_open()) {
        m_Socket.close(ec);
    }
    
    m_IsReceiving = false;
}

void KcpChannel::DoUpdate() {
    /* 功能：更新通道状态
       处理：检查重传和超时消息 */
    if (m_State != ConnectionState::Connected) {
        return;
    }
    
    // 检查消息超时
    auto timeoutMessages = m_MessagePool->CheckTimeoutMessages();
    
    // 重新发送超时消息
    for (auto& message : timeoutMessages) {
        std::lock_guard<std::mutex> lock(m_SendQueueMutex);
        m_SendQueue.push_front(message);  // 超时消息优先发送
    }
    
    // 如果有待发送消息，确保发送流程启动
    if (!m_SendQueue.empty()) {
        asio::post(m_Strand, [this]() {
            // 使用最新的状态和队列
            if (m_KcpSession->IsCreated() && !m_SendQueue.empty()) {
                SendNextMessage();
            }
        });
    }
}

bool KcpChannel::SendMsg(std::shared_ptr<NetworkMessage> message) {
    /* 功能：发送消息
       参数：message-要发送的消息
       返回：发送操作是否成功启动 */
    if (!message || m_State != ConnectionState::Connected || !m_KcpSession->IsCreated()) {
        return false;
    }
    
    message->UpdateTimestamp();
    message->UpdateLastSendTime();
    
    // 添加到消息池进行可靠性管理
    if (m_MessagePool->AddMessage(message, ChannelType::KCP)) {
        // 加入发送队列
        {
            std::lock_guard<std::mutex> lock(m_SendQueueMutex);
            m_SendQueue.push_back(message);
        }
        
        // 在strand中发送，确保线程安全
        asio::post(m_Strand, [this]() {
            // 使用最新的状态和队列
            if (m_KcpSession->IsCreated() && !m_SendQueue.empty()) {
                SendNextMessage();
            }
        });
        
        return true;
    }
    
    return false;
}

void KcpChannel::SetMessageCallback(MessageReceiveCallback callback) {
    BaseNetworkChannel::SetMessageCallback(callback);
}

void KcpChannel::SetConnectionCallback(ConnectionStateCallback callback) {
    BaseNetworkChannel::SetConnectionCallback(callback);
}

ConnectionState KcpChannel::GetConnectionState() const {
    return m_State;
}

NetworkStats KcpChannel::GetNetworkStats() const {
    std::lock_guard<std::mutex> lock(m_StatsMutex);
    return m_Stats;
}

ChannelType KcpChannel::GetChannelType() const {
    return ChannelType::KCP;
}

uint32_t KcpChannel::GetLatency() const {
    std::lock_guard<std::mutex> lock(m_StatsMutex);
    return m_Stats.LatestRtt;
}

void KcpChannel::SetNodelay(bool nodelay, int interval, int resend, bool nc) {
    /* 功能：设置KCP传输模式
       参数：nodelay-是否启用无延迟模式，interval-内部更新间隔(ms)
             resend-快速重传触发次数，nc-是否关闭流控 */
    if (m_KcpSession) {
        m_KcpSession->SetNodelay(nodelay, interval, resend, nc);
    }
}

void KcpChannel::SetWindowSize(int sndwnd, int rcvwnd) {
    /* 功能：设置KCP窗口大小
       参数：sndwnd-发送窗口大小，rcvwnd-接收窗口大小 */
    if (m_KcpSession) {
        m_KcpSession->SetWindowSize(sndwnd, rcvwnd);
    }
}

void KcpChannel::SetMtu(int mtu) {
    /* 功能：设置最大传输单元
       参数：mtu-MTU大小 */
    if (m_KcpSession) {
        m_KcpSession->SetMtu(mtu);
    }
}

void KcpChannel::SetMinRto(int minrto) {
    /* 功能：设置最小RTO
       参数：minrto-最小重传超时时间(ms) */
    if (m_KcpSession) {
        m_KcpSession->SetMinRto(minrto);
    }
}

void KcpChannel::SetFastResend(int fastresend) {
    /* 功能：设置快速重传
       参数：fastresend-触发快速重传的ACK跳过次数 */
    if (m_KcpSession) {
        m_KcpSession->SetFastResend(fastresend);
    }
}

void KcpChannel::StartReceive() {
    /* 功能：启动接收流程 */
    if (!m_Socket.is_open() || m_State != ConnectionState::Connected || m_IsReceiving) {
        return;
    }
    
    m_IsReceiving = true;
    
    // 创建一个共享指针来保存接收缓冲区的引用，确保在异步操作期间缓冲区存活
    auto bufferPtr = std::make_shared<std::vector<uint8_t>>(m_RawReadBuffer);
    
    // 异步接收UDP数据
    m_Socket.async_receive_from(
        asio::buffer(*bufferPtr), m_RemoteEndpoint,
        asio::bind_executor(m_Strand, [this, bufferPtr](const asio::error_code& ec, std::size_t bytes_transferred) {
            m_IsReceiving = false;
            
            if (!ec && bytes_transferred > 0) {
                // 复制接收到的数据到m_RawReadBuffer以便后续处理
                if (bytes_transferred <= m_RawReadBuffer.size()) {
                    std::memcpy(m_RawReadBuffer.data(), bufferPtr->data(), bytes_transferred);
                }
            }
            
            HandleUdpReceive(ec, bytes_transferred);
        }));
}

void KcpChannel::StartKcpUpdate() {
    /* 功能：启动KCP更新定时器
       处理：定期调用KCP的update方法 */
    if (!m_KcpSession->IsCreated() || !m_UpdateTimer) {
        return;
    }
    
    uint32_t current = static_cast<uint32_t>(GetCurrentTimeMillis());
    m_KcpSession->Update(current);
    
    // 处理接收到的数据
    HandleKcpReceive();
    
    // 计算下次更新时间
    uint32_t nextUpdate = m_KcpSession->Check(current) - current;
    if (nextUpdate > 100) nextUpdate = 100;  // 最大100ms更新间隔
    if (nextUpdate < 1) nextUpdate = 1;      // 最小1ms更新间隔
    
    // 设置下次更新定时器
    m_UpdateTimer->expires_after(std::chrono::milliseconds(nextUpdate));
    m_UpdateTimer->async_wait(asio::bind_executor(m_Strand, [this](const asio::error_code& ec) {
        if (!ec) {
            // 不需要先检查状态，让StartKcpUpdate内部处理状态检查
            StartKcpUpdate();
        }
    }));
}

void KcpChannel::HandleUdpReceive(const asio::error_code& ec, std::size_t bytes_transferred) {
    /* 功能：处理UDP接收回调
       参数：ec-错误码，bytes_transferred-接收到的字节数 */
    if (!ec) {
        if (bytes_transferred > 0) {
            // 统计接收的字节数
            UpdateNetworkStats(0, bytes_transferred, false, false);
            
            // 检查是否是握手确认消息
            if (bytes_transferred >= 9 && std::string(reinterpret_cast<char*>(m_RawReadBuffer.data()), 9) == "CONNECTED") {
                // 连接已建立，无需特殊处理
            }
            else {
                // 输入数据到KCP
                if (m_KcpSession->IsCreated()) {
                    ikcp_input(static_cast<ikcpcb*>(m_KcpSession->GetKcpCb()), 
                               reinterpret_cast<char*>(m_RawReadBuffer.data()), 
                               static_cast<long>(bytes_transferred));
                }
            }
        }
        
        // 继续接收
        StartReceive();
    }
    else if (ec != asio::error::operation_aborted) {
        // 接收失败
        std::string errMsg = "Receive error: " + ec.message();
        UpdateConnectionState(ConnectionState::Failed, errMsg);
        
        // 启动重连
        StartReconnect();
    }
}

void KcpChannel::HandleKcpReceive() {
    /* 功能：处理KCP接收到的数据
       处理：从KCP接收数据并反序列化为消息 */
    if (!m_KcpSession->IsCreated()) {
        return;
    }
    
    // 设置最大消息接收大小限制，防止恶意消息导致内存耗尽
    const size_t MAX_MESSAGE_SIZE = 10 * 1024 * 1024; // 10MB
    
    while (true) {
        // 从KCP接收数据
        int recvLen = m_KcpSession->Recv(m_ReadBuffer.data(), static_cast<int>(m_ReadBuffer.size()));
        if (recvLen <= 0) {
            break;  // 无更多数据
        }
        
        // 安全性检查：消息大小超出合理范围
        if (recvLen > MAX_MESSAGE_SIZE) {
            // 消息过大，可能是恶意攻击，记录错误并丢弃
            UpdateNetworkStats(0, static_cast<uint64_t>(recvLen), false, false);
            continue;
        }
        
        // 尝试使用零复制反序列化消息
        std::shared_ptr<NetworkMessage> message;
        try {
            message = NetworkMessage::DeserializeZeroCopy(m_ReadBuffer.data(), recvLen);
        }
        catch (const std::exception& e) {
            // 反序列化过程中出现异常，记录错误并丢弃
            continue;
        }
        
        if (message) {
            // 发送确认消息
            m_MessagePool->AcknowledgeMessage(message->GetHeader().MessageId, ChannelType::KCP);
            
            // 更新统计信息
            UpdateNetworkStats(0, static_cast<uint64_t>(recvLen), false, true);
            
            // 检查是否是心跳包，更新RTT
            if (message->HasFlag(MessageFlags::FLAG_KEEPALIVE) && message->GetHeader().MessageId == 0) {
                uint64_t sendTime = message->GetHeader().Timestamp;
                uint64_t currentTime = GetCurrentTimeMillis();
                if (currentTime > sendTime) {
                    UpdateRtt(static_cast<uint32_t>(currentTime - sendTime));
                }
            }
            
            // 使用基类中的线程安全回调函数
            InvokeMessageCallback(message);
        }
    }
}

void KcpChannel::SendNextMessage() {
    /* 功能：发送队列中的下一条消息 */
    std::shared_ptr<NetworkMessage> message = nullptr;
    
    // 首先尝试从无锁队列获取消息
    if (m_MessagePool->DequeueOutgoingMessage(message)) {
        // 使用无锁队列获取到消息，直接处理
    } else {
        // 如果无锁队列为空，则从优先级队列获取
        std::lock_guard<std::mutex> lock(m_SendQueueMutex);
        if (m_SendQueue.empty()) {
            return;
        }
        
        message = m_SendQueue.front();
        m_SendQueue.pop_front();
    }
    
    if (!message || !m_KcpSession->IsCreated() || m_State != ConnectionState::Connected) {
        return;
    }
    
    // 序列化消息
    auto buffer = message->Serialize();
    
    // 通过KCP发送消息
    int sentBytes = m_KcpSession->Send(buffer.data(), static_cast<int>(buffer.size()));
    
    if (sentBytes > 0) {
        // 发送成功，更新统计信息
        UpdateNetworkStats(sentBytes, 0, true, false);
        
        // 继续发送下一条消息
        std::shared_ptr<NetworkMessage> nextMessage = nullptr;
        if (m_MessagePool->DequeueOutgoingMessage(nextMessage)) {
            // 如果无锁队列中还有消息，继续发送
            SendNextMessage();
        } else {
            // 检查优先级队列
            std::lock_guard<std::mutex> lock(m_SendQueueMutex);
            if (!m_SendQueue.empty()) {
                SendNextMessage();
            }
        }
    }
    else {
        // 发送失败，可能是KCP发送窗口已满
        // 将消息放回队列，稍后重试
        {
            std::lock_guard<std::mutex> lock(m_SendQueueMutex);
            m_SendQueue.push_front(message);
        }
    }
}

void KcpChannel::HandleMessageAck(uint32_t messageId, bool success) {
    /* 功能：处理消息确认
       参数：messageId-消息ID，success-是否成功 */
    if (success) {
        // 消息成功送达
    }
    else {
        // 消息传输失败，超时或放弃
        std::lock_guard<std::mutex> lock(m_StatsMutex);
        m_Stats.PacketLoss++;
    }
}

void KcpChannel::SendKeepAlive() {
    /* 功能：发送心跳包
       处理：创建并发送心跳消息，设置下一次心跳定时器 */
    if (m_State != ConnectionState::Connected) {
        return;
    }
    
    // 创建心跳消息
    auto keepAliveMsg = std::make_shared<NetworkMessage>(0, MessagePriority::High);  // 0为心跳消息ID
    keepAliveMsg->SetBody(nullptr, 0);  // 空消息体
    
    // 发送心跳
    SendMsg(keepAliveMsg);
    
    // 设置下一次心跳
    if (m_KeepAliveTimer) {
        m_KeepAliveTimer->expires_after(std::chrono::milliseconds(m_KeepAliveInterval));
        m_KeepAliveTimer->async_wait(asio::bind_executor(m_Strand, [this](const asio::error_code& ec) {
            if (!ec) {
                // 不先检查状态，让SendKeepAlive内部处理状态检查
                SendKeepAlive();
            }
        }));
    }
}

void KcpChannel::StartReconnect() {
    /* 功能：启动重连流程
       处理：根据重连策略设置延迟后尝试重连 */
    if (m_State == ConnectionState::Reconnecting) {
        return;
    }
    
    if (m_ReconnectAttempts >= m_ReconnectMaxAttempts) {
        UpdateConnectionState(ConnectionState::Disconnected, "Maximum reconnect attempts reached");
        return;
    }
    
    UpdateConnectionState(ConnectionState::Reconnecting, "Connection lost, attempting to reconnect");
    
    m_ReconnectAttempts++;
    uint32_t delay = CalculateReconnectDelay();
    
    if (m_ReconnectTimer) {
        m_ReconnectTimer->expires_after(std::chrono::milliseconds(delay));
        m_ReconnectTimer->async_wait(asio::bind_executor(m_Strand, [this](const asio::error_code& ec) {
            if (!ec) {
                // 重新初始化KCP会话
                if (m_KcpSession) {
                    m_KcpSession->Release();
                    m_KcpConv = static_cast<uint32_t>(std::chrono::system_clock::now().time_since_epoch().count() & 0xFFFFFFFF);
                    m_KcpSession->Create(m_KcpConv);
                    m_KcpSession->SetOutput([this](const uint8_t* data, int size) -> int {
                        return UdpOutput(data, size);
                    });
                }
                
                // 尝试重新连接
                asio::error_code socketEc;
                if (m_Socket.is_open()) {
                    m_Socket.close(socketEc);
                }
                m_Socket.open(asio::ip::udp::v4());
                
                Connect(m_Host, m_Port);
            }
        }));
    }
}

void KcpChannel::UpdateConnectionState(ConnectionState newState, const std::string& reason) {
    /* 功能：更新连接状态 - 使用基类实现
       参数：newState-新状态，reason-状态变更原因 */
    BaseNetworkChannel::UpdateConnectionState(newState, reason);
}

void KcpChannel::UpdateNetworkStats(uint64_t bytesSent, uint64_t bytesReceived, bool messageSent, bool messageReceived) {
    /* 功能：更新网络统计信息
       参数：bytesSent-发送字节数，bytesReceived-接收字节数
             messageSent-是否为消息发送，messageReceived-是否为消息接收 */
    std::lock_guard<std::mutex> lock(m_StatsMutex);
    
    m_Stats.TotalBytesSent += bytesSent;
    m_Stats.TotalBytesReceived += bytesReceived;
    
    if (messageSent) {
        m_Stats.MessagesSent++;
    }
    
    if (messageReceived) {
        m_Stats.MessagesReceived++;
    }
}

void KcpChannel::UpdateRtt(uint32_t rtt) {
    /* 功能：更新RTT统计
       参数：rtt-往返时间（毫秒） */
    std::lock_guard<std::mutex> lock(m_StatsMutex);
    
    m_RttSamples.push_back(rtt);
    
    // 保留最近10个RTT样本
    if (m_RttSamples.size() > 10) {
        m_RttSamples.erase(m_RttSamples.begin());
    }
    
    // 计算平均RTT
    if (!m_RttSamples.empty()) {
        uint64_t sum = 0;
        for (auto sample : m_RttSamples) {
            sum += sample;
        }
        m_Stats.AverageRtt = static_cast<uint32_t>(sum / m_RttSamples.size());
    }
    
    m_Stats.LatestRtt = rtt;
}

uint32_t KcpChannel::CalculateReconnectDelay() const {
    /* 功能：计算重连延迟（指数退避）
       返回：下次重连延迟（毫秒） */
    uint32_t delay = m_ReconnectInitialDelay;
    
    // 指数退避
    for (uint32_t i = 1; i < m_ReconnectAttempts && delay < m_ReconnectMaxDelay / 2; ++i) {
        delay *= 2;
    }
    
    return std::min(delay, m_ReconnectMaxDelay);
}

int KcpChannel::UdpOutput(const uint8_t* data, int size) {
    /* 功能：UDP发送回调，由KCP内部调用
       参数：data-待发送数据，size-数据长度
       返回：实际发送的字节数 */
    if (!m_Socket.is_open() || !data || size <= 0) {
        return -1;
    }
    
    try {
        asio::error_code ec;
        std::size_t sent = m_Socket.send_to(asio::buffer(data, size), m_RemoteEndpoint, 0, ec);
        
        if (ec) {
            return -1;
        }
        
        return static_cast<int>(sent);
    }
    catch (...) {
        return -1;
    }
}

void KcpChannel::DoSendMessage(std::shared_ptr<NetworkMessage> message) {
    /* 功能：发送消息的具体实现
       参数：message-待发送的网络消息
       说明：该方法通过KCP协议发送消息 */
    if (m_State != ConnectionState::Connected || !m_KcpSession->IsCreated()) {
        return;
    }
    
    asio::post(m_Strand, [this, message]() {
        if (m_State != ConnectionState::Connected || !m_KcpSession->IsCreated()) {
            return;
        }
        
        // 序列化消息
        auto buffer = message->Serialize();
        
        // 通过KCP发送消息
        int sentBytes = m_KcpSession->Send(buffer.data(), static_cast<int>(buffer.size()));
        
        if (sentBytes > 0) {
            // 更新统计信息
            UpdateNetworkStats(sentBytes, 0, true, false);
            
            // 处理消息确认和重传（由MessagePool管理）
            message->UpdateLastSendTime();
            message->IncrementResendCount();
            
            // 添加到等待确认的消息列表
            m_MessagePool->AddMessage(message, ChannelType::KCP);
        }
    });
}

void KcpChannel::SetupServerConnection(const asio::ip::udp::endpoint& clientEndpoint) {
    /* 功能：设置服务器端KCP连接
       参数：clientEndpoint-客户端UDP端点
       说明：该方法在服务器端使用，为接收到的客户端连接设置KCP通道 */
    try {
        // 设置远程端点
        m_RemoteEndpoint = clientEndpoint;
        
        // 确保Socket已打开
        if (!m_Socket.is_open()) {
            asio::error_code ec;
            m_Socket.open(asio::ip::udp::v4(), ec);
            if (ec) {
                return;
            }
        }
        
        // 设置KCP回调
        m_KcpSession->SetOutput([this](const uint8_t* data, int size) -> int {
            return UdpOutput(data, size);
        });
        
        // 启动KCP更新定时器
        StartKcpUpdate();
        
        // 设置状态为已连接
        UpdateConnectionState(ConnectionState::Connected, "Server accepted connection");
        
        // 启动接收
        StartReceive();
        
        // 启动心跳
        SendKeepAlive();
    }
    catch (const std::exception& e) {
        UpdateConnectionState(ConnectionState::Failed, std::string("Server connection setup failed: ") + e.what());
    }
}

void KcpChannel::HandleReceivedData(const uint8_t* data, size_t length, const asio::ip::udp::endpoint& sender) {
    /* 功能：处理服务器端接收到的KCP数据
       参数：data-接收到的数据，length-数据长度，sender-发送方端点
       说明：该方法处理服务器端接收到的来自客户端的KCP数据 */
    if (!data || length == 0 || !m_KcpSession->IsCreated()) {
        return;
    }
    
    // 更新远程端点（以防客户端IP或端口变化）
    m_RemoteEndpoint = sender;
    
    // 更新活动时间和统计信息
    UpdateNetworkStats(0, length, false, false);
    
    // 判断是否是连接握手包
    if (length >= 4 && data[0] == 'C' && data[1] == 'O' && data[2] == 'N' && data[3] == 'N') {
        // 这是连接请求包，发送连接确认
        auto connectAck = std::make_shared<std::vector<uint8_t>>(9);
        std::memcpy(connectAck->data(), "CONNECTED", 9);
        
        m_Socket.async_send_to(asio::buffer(*connectAck), sender,
            asio::bind_executor(m_Strand, [this, connectAck](const asio::error_code& ec, std::size_t bytes_transferred) {
                // 发送确认完成，不需要特殊处理
            }));
            
        // 如果消息中包含会话ID (conv)，则使用它
        if (length >= 8) {
            uint32_t conv;
            std::memcpy(&conv, &data[4], 4);
            
            // 重新初始化KCP会话
            m_KcpSession->Release();
            m_KcpConv = conv;
            m_KcpSession->Create(m_KcpConv);
            m_KcpSession->SetOutput([this](const uint8_t* d, int s) -> int {
                return UdpOutput(d, s);
            });
        }
    }
    else {
        // 常规KCP数据，输入到KCP进行处理
        ikcp_input(static_cast<ikcpcb*>(m_KcpSession->GetKcpCb()), 
                   reinterpret_cast<const char*>(data), 
                   static_cast<long>(length));
                   
        // 处理可能接收到的KCP数据
        HandleKcpReceive();
    }
}

// 发送应用层确认消息
void KcpChannel::SendAck(uint32_t messageId) {
    // 创建确认消息
    auto ackMessage = std::make_shared<NetworkMessage>(messageId);
    
    // 设置确认标志
    ackMessage->SetFlag(MessageFlags::FLAG_ACK);
    
    // 不需要额外数据，清空消息体
    ackMessage->SetBody(nullptr, 0);
    
    // 通过KCP发送
    m_KcpSession->Send(reinterpret_cast<const uint8_t*>(&messageId), sizeof(messageId));
}

} // namespace SeanNetwork
